/**
 * 地图绘制工具类
 * 封装高德地图绘制功能，包括线段、多边形、圆形的绘制和测量
 */
export default class DrawingTools {
  /**
   * 构造函数
   * @param {Object} map - 高德地图实例
   * @param {Object} options - 配置选项
   */
  constructor(map, options = {}) {
    this.map = map;
    this.options = Object.assign(
      {
        // 默认样式配置
        styles: {
          polyline: {
            strokeColor: '#0096ff',
            strokeOpacity: 1,
            strokeWeight: 3
          },
          polygon: {
            fillColor: 'rgba(0, 150, 255, 0.3)',
            strokeColor: '#0096ff',
            strokeOpacity: 1,
            strokeWeight: 3
          },
          circle: {
            fillColor: 'rgba(0, 150, 255, 0.3)',
            strokeColor: '#0096ff',
            strokeOpacity: 1,
            strokeWeight: 3
          },
          label: {
            'background-color': 'rgba(11, 50, 89, 0.8)',
            'border-radius': '4px',
            'color': 'white',
            'padding': '5px 10px',
            'font-size': '12px',
            'border': '1px solid rgba(255, 255, 255, 0.2)',
            'box-shadow': '0 2px 6px rgba(0, 0, 0, 0.3)'
          }
        },
        // 是否自动添加标签
        autoLabel: true
      },
      options
    );

    // 初始化属性
    this.mouseTool = null;
    this.drawingMode = null;
    this.currentOverlay = null;
    this.drawnItems = {
      polylines: [],
      polygons: [],
      circles: [],
      labels: []
    };

    // 初始化绘制工具
    this.init();
  }

  /**
   * 初始化绘制工具
   */
  init() {
    // 初始化鼠标工具
    this.mouseTool = new AMap.MouseTool(this.map);

    // 监听绘制完成事件
    this.mouseTool.on('draw', (event) => {
      this.currentOverlay = event.obj;

      // 根据不同的绘制模式处理结果
      switch (this.drawingMode) {
        case 'polyline':
          this.finishPolyline(event.obj);
          break;
        case 'polygon':
          this.finishPolygon(event.obj);
          break;
        case 'circle':
          this.finishCircle(event.obj);
          break;
      }

      // 触发绘制完成事件
      if (this.onDrawComplete) {
        this.onDrawComplete({
          type: this.drawingMode,
          overlay: event.obj,
          measurement: this.getMeasurement()
        });
      }
      
      // 注意：不要在这里关闭绘制工具，否则会导致测量信息面板消失
      // this.mouseTool.close();
    });
  }

  /**
   * 开始绘制
   * @param {string} mode - 绘制模式：'polyline', 'polygon', 'circle'
   * @returns {DrawingTools} - 返回实例本身，支持链式调用
   */
  startDrawing(mode) {
    try {
      console.log('开始绘制，模式:', mode);

      // 如果当前已经在绘制中，先关闭绘制工具
      // 注意：只关闭绘制工具，不清除已绘制的内容
      this.mouseTool.close();

      // 设置绘制模式
      this.drawingMode = mode;

      // 根据模式启动不同的绘制工具
      switch (mode) {
        case 'polyline':
          this.mouseTool.polyline(this.options.styles.polyline);
          break;
        case 'polygon':
          this.mouseTool.polygon(this.options.styles.polygon);
          break;
        case 'circle':
          this.mouseTool.circle(this.options.styles.circle);
          break;
        default:
          return this;
      }

      console.log('绘制工具已启动');
    } catch (error) {
      console.error('开始绘制出错:', error);
    }

    return this;
  }

  /**
   * 完成线段绘制
   * @param {Object} polyline - 绘制的线段对象
   * @private
   */
  finishPolyline(polyline) {
    console.log('完成线段绘制');

    // 将线段添加到已绘制项目中
    this.drawnItems.polylines.push(polyline);

    // 计算线段长度
    const path = polyline.getPath();
    const length = this.calculateDistance(path);
    const formattedLength = this.formatDistance(length);
    console.log('线段长度:', formattedLength);

    // 保存测量结果
    this._measurement = {
      type: 'polyline',
      value: formattedLength,
      rawValue: length,
      additionalValue: null
    };

    // 在线段上添加标注
    if (this.options.autoLabel) {
      this.addMeasureLabel(polyline, formattedLength);
    }
    
    // 注意：不要在这里关闭绘制工具，否则会导致测量信息面板消失
    // this.mouseTool.close();
  }

  /**
   * 完成多边形绘制
   * @param {Object} polygon - 绘制的多边形对象
   * @private
   */
  finishPolygon(polygon) {
    console.log('完成多边形绘制');

    // 将多边形添加到已绘制项目中
    this.drawnItems.polygons.push(polygon);

    // 计算多边形面积
    const area = polygon.getArea();
    const formattedArea = this.formatArea(area);
    console.log('多边形面积:', formattedArea);

    // 保存测量结果
    this._measurement = {
      type: 'polygon',
      value: formattedArea,
      rawValue: area,
      additionalValue: null
    };

    // 在多边形中心添加标注
    if (this.options.autoLabel) {
      this.addMeasureLabel(polygon, formattedArea, true);
    }
    
    // 注意：不要在这里关闭绘制工具，否则会导致测量信息面板消失
    // this.mouseTool.close();
  }

  /**
   * 完成圆形绘制
   * @param {Object} circle - 绘制的圆形对象
   * @private
   */
  finishCircle(circle) {
    console.log('完成圆形绘制');

    // 将圆形添加到已绘制项目中
    this.drawnItems.circles.push(circle);

    // 获取圆心和半径
    const center = circle.getCenter();
    const radius = circle.getRadius();
    const formattedRadius = this.formatDistance(radius);
    const area = Math.PI * radius * radius;
    const formattedArea = this.formatArea(area);

    console.log('圆心:', center.toString(), '半径:', formattedRadius, '面积:', formattedArea);

    // 保存测量结果
    this._measurement = {
      type: 'circle',
      value: formattedRadius,
      rawValue: radius,
      additionalValue: formattedArea,
      rawAdditionalValue: area
    };
    
    // 注意：不要在这里关闭绘制工具，否则会导致测量信息面板消失
    // this.mouseTool.close();

    // 在圆形中心添加标注
    if (this.options.autoLabel) {
      this.addMeasureLabel(circle, `半径: ${formattedRadius}\n面积: ${formattedArea}`, true);
    }
  }

  /**
   * 获取当前测量结果
   * @returns {Object|null} 测量结果对象
   */
  getMeasurement() {
    return this._measurement || null;
  }

  /**
   * 计算路径距离（米）
   * @param {Array} path - 路径坐标数组
   * @returns {number} 距离（米）
   */
  calculateDistance(path) {
    return AMap.GeometryUtil.distanceOfLine(path);
  }

  /**
   * 格式化距离显示
   * @param {number} distance - 距离（米）
   * @returns {string} 格式化后的距离
   */
  formatDistance(distance) {
    if (distance >= 1000) {
      return (distance / 1000).toFixed(2) + ' 公里';
    } else {
      return distance.toFixed(2) + ' 米';
    }
  }

  /**
   * 格式化面积显示
   * @param {number} area - 面积（平方米）
   * @returns {string} 格式化后的面积
   */
  formatArea(area) {
    if (area >= 1000000) {
      return (area / 1000000).toFixed(2) + ' 平方公里';
    } else if (area >= 10000) {
      return (area / 10000).toFixed(2) + ' 公顷';
    } else {
      return area.toFixed(2) + ' 平方米';
    }
  }

  /**
   * 在覆盖物上添加测量结果标签
   * @param {Object} overlay - 覆盖物对象（线段、多边形或圆形）
   * @param {string} text - 标签文本
   * @param {boolean} isCenter - 是否在中心点添加标签
   * @returns {Object} 创建的标签对象
   */
  addMeasureLabel(overlay, text, isCenter = false) {
    try {
      let position;

      if (isCenter) {
        // 对于多边形和圆形，在中心点添加标签
        if (overlay.getCenter) {
          // 圆形
          position = overlay.getCenter();
        } else {
          // 多边形
          const bounds = overlay.getBounds();
          position = bounds.getCenter();
        }
      } else {
        // 对于线段，在中间点添加标签
        const path = overlay.getPath();
        if (path.length > 1) {
          // 取路径的中间点
          const midIndex = Math.floor(path.length / 2);
          position = path[midIndex];
        } else {
          // 如果只有一个点，直接使用该点
          position = path[0];
        }
      }

      // 创建文本标记
      const label = new AMap.Text({
        position: position,
        text: text,
        anchor: 'center',
        style: this.options.styles.label,
        zIndex: 101
      });

      // 将标签添加到地图
      label.setMap(this.map);

      // 保存标签引用以便后续清除
      if (!this.drawnItems.labels) {
        this.drawnItems.labels = [];
      }
      this.drawnItems.labels.push(label);

      return label;
    } catch (error) {
      console.error('添加测量标签出错:', error);
      return null;
    }
  }

  /**
   * 清除所有绘制
   * @returns {DrawingTools} - 返回实例本身，支持链式调用
   */
  clearDrawings() {
    try {
      console.log('清除所有绘制 - 开始');

      // 关闭绘制工具
      this.mouseTool.close();

      // 清除所有覆盖物
      this.map.clearMap();

      // 清空已绘制项目数组
      this.drawnItems = {
        polylines: [],
        polygons: [],
        circles: [],
        labels: []
      };

      // 重置绘制模式
      this.drawingMode = null;
      this.currentOverlay = null;
      this._measurement = null;

      console.log('所有绘制清除完成');
    } catch (error) {
      console.error('清除所有绘制出错:', error);
    }

    return this;
  }

  /**
   * 设置绘制完成回调函数
   * @param {Function} callback - 回调函数，参数为绘制结果对象
   * @returns {DrawingTools} - 返回实例本身，支持链式调用
   */
  setDrawCompleteCallback(callback) {
    this.onDrawComplete = callback;
    return this;
  }

  /**
   * 销毁绘制工具
   */
  destroy() {
    this.clearDrawings();
    this.mouseTool = null;
    this.map = null;
    this.options = null;
    this.drawnItems = null;
    this.onDrawComplete = null;
  }
}